local 地图处理类 = class()

function 地图处理类:初始化()
	self.地图编号 = {
		1001,
		1002,
		1003,
		1004,
		1005,
		1006,
		1007,
		1008,
		1009,
		1012,
		1013,
		1014,
		1015,
		1016,
		1017,
		1018,
		1019,
		1020,
		1021,
		1022,
		1023,
		1024,
		1025,
		1026,
		1028,
		1029,
		1030,
		1031,
		1032,
		1033,
		1034,
		1035,
		1036,
		1037,
		1038,
		1040,
		1041,
		1042,
		1043,
		1044,
		1046,
		1049,
		1050,
		1051,
		1052,
		1054,
		1056,
		1057,
		1070,
		1072,
		1075,
		1077,
		1078,
		1079,
		1080,
		1081,
		1082,
		1083,
		1085,
		1087,
		1090,
		1091,
		1092,
		1093,
		1094,
		1095,
		1098,
		1099,
		1100,
		1101,
		1103,
		1104,
		1105,
		1106,
		1107,
		1110,
		1111,
		1112,
		1113,
		1114,
		1115,
		1116,
		1117,
		1118,
		1119,
		1120,
		1121,
		1122,
		1123,
		1124,
		1125,
		1126,
		1127,
		1128,
		1129,
		1130,
		1131,
		1132,
		1133,
		1134,
		1135,
		1137,
		1138,
		1139,
		1140,
		1141,
		1142,
		1143,
		1144,
		1145,
		1146,
		1147,
		1149,
		1150,
		1152,
		1153,
		1154,
		1155,
		1156,
		1165,
		1167,
		1168,
		1170,
		1171,
		1173,
		1174,
		1175,
		1177,
		1178,
		1179,
		1180,
		1181,
		1182,
		1183,
		1186,
		1187,
		1188,
		1189,
		1190,
		1191,
		1192,
		1193,
		1197,
		1198,
		1201,
		1202,
		1203,
		1204,
		1205,
		1206,
		1207,
		1208,
		1209,
		1210,
		1211,
		1212,
		1213,
		1214,
		1215,
		1216,
		1217,
		1218,
		1219,
		1220,
		1221,
		1222,
		1223,
		1224,
		1225,
		1226,
		1227,
		1228,
		1229,
		1230,
		1231,
		1232,
		1233,
		1234,
		1235,
		1236,
		1237,
		1238,
		1239,
		1241,
		1242,
		1243,
		1245,
		1246,
		1248,
		1249,
		1250,
		1251,
		1252,
		1253,
		1256,
		1257,
		1258,
		1259,
		1272,
		1273,
		1306,
		1310,
		1311,
		1312,
		1313,
		1314,
		1315,
		1316,
		1317,
		1318,
		1319,
		1320,
		1321,
		1322,
		1323,
		1324,
		1325,
		1326,
		1327,
		1328,
		1329,
		1330,
		1331,
		1332,
		1333,
		1334,
		1335,
		1336,
		1337,
		1338,
		1339,
		1340,
		1341,
		1342,
		1343,
		1380,
		1382,
		1400,
		1401,
		1402,
		1403,
		1404,
		1405,
		1406,
		1407,
		1408,
		1409,
		1410,
		1411,
		1412,
		1413,
		1414,
		1415,
		1416,
		1417,
		1418,
		1420,
		1421,
		1422,
		1424,
		1425,
		1426,
		1427,
		1428,
		1429,
		1430,
		1446,
		1447,
		1501,
		1502,
		1503,
		1504,
		1505,
		1506,
		1507,
		1508,
		1509,
		1511,
		1512,
		1513,
		1514,
		1523,
		1524,
		1525,
		1526,
		1527,
		1528,
		1529,
		1531,
		1532,
		1533,
		1534,
		1535,
		1536,
		1537,
		1605,
		1606,
		1607,
		1608,
		1810,
		1811,
		1812,
		1813,
		1814,
		1815,
		1820,
		1821,
		1822,
		1823,
		1824,
		1825,
		1830,
		1831,
		1832,
		1833,
		1834,
		1835,
		1840,
		1841,
		1842,
		1843,
		1844,
		1845,
		1850,
		1851,
		1852,
		1853,
		1854,
		1855,
		1860,
		1861,
		1862,
		1863,
		1864,
		1865,
		1870,
		1871,
		1872,
		1873,
		1874,
		1875,
		1876,
		1885,
		1886,
		1887,
		1888,
		1890,
		1891,
		1892,
		1910,
		1911,
		1912,
		1913,
		1914,
		1915,
		1916,
		1920,
		1930,
		1931,
		1932,
		1933,
		1934,
		1935,
		1936,
		1937,
		1938,
		1939,
		1940,
		1941,
		1942,
		1943,
		1944,
		1945,
		1946,
		1947,
		1948,
		1949,
		1950,
		1951,
		1952,
		1953,
		1954,
		1955,
		1958,
		1959,
		1960,
		1961,
		1962,
		1963,
		1964,
		1965,
		1966,
		1967,
		1968,
		1969,
		1970,
		1971,
		2000,
		2001,
		2002,
		2003,
		2004,
		2005,
		2006,
		2007,
		4001,
		5000
	}
	self.地图数据 = {}
	self.地图玩家 = {}
	self.地图单位 = {}
	self.队伍距离 = 50
	self.地图坐标 = {}
	self.单位编号 = {}
	self.遇怪地图 = {}

	for n = 1, #self.地图编号 do
		self.地图数据[self.地图编号[n]] = {
			npc = {},
			单位 = {},
			传送圈 = {}
		}
		self.地图玩家[self.地图编号[n]] = {}
		self.地图坐标[self.地图编号[n]] = 地图坐标类(self.地图编号[n])
		self.地图单位[self.地图编号[n]] = {}
		self.单位编号[self.地图编号[n]] = 1000

		if 取场景等级(self.地图编号[n]) ~= nil then
			self.遇怪地图[self.地图编号[n]] = true
		end
	end

	local mgdt = {
		[1604.0] = 1070,
		[1603.0] = 1092,
		[1613.0] = 1201,
		[1611.0] = 1140,
		[1620.0] = 1514,
		[1616.0] = 2004,
		[1615.0] = 1114,
		[1614.0] = 1207,
		[1600.0] = 1514,
		[1601.0] = 1514,
		[1606.0] = 1040,
		[1605.0] = 1193,
		[1602.0] = 1146,
		[1607.0] = 1208,
		[1609.0] = 1116,
		[1617.0] = 1041,
		[1618.0] = 1202,
		[1619.0] = 2001,
		[1610.0] = 1198,
		[1612.0] = 1002,
		[1608.0] = 1142
	}

	for n = 1600, 1620 do
		self.地图数据[n] = {
			npc = {},
			单位 = {},
			传送圈 = {}
		}
		self.地图玩家[n] = {}
		self.地图坐标[n] = 地图坐标类(mgdt[n])
		self.地图单位[n] = {}
		self.单位编号[n] = 1000
	end

	for n = 3000, 3150 do
		self.地图数据[n] = {
			npc = {},
			单位 = {},
			传送圈 = {}
		}
		self.地图玩家[n] = {}
		local aa = (n + 1) % 5

		if aa == 1 then
			self.地图坐标[n] = 地图坐标类(1004)
		elseif aa == 2 then
			self.地图坐标[n] = 地图坐标类(1005)
		elseif aa == 3 then
			self.地图坐标[n] = 地图坐标类(1006)
		elseif aa == 4 then
			self.地图坐标[n] = 地图坐标类(1007)
		elseif aa == 0 then
			self.地图坐标[n] = 地图坐标类(1008)
		end

		self.地图单位[n] = {}
		self.单位编号[n] = 1000
	end

	for k, v in pairs(场景置换) do
		self.地图数据[k] = {
			npc = {},
			单位 = {},
			传送圈 = {}
		}
		self.地图玩家[k] = {}
		self.地图坐标[k] = 地图坐标类(v[1])
		self.地图单位[k] = {}
		self.单位编号[k] = 1000
	end

	local 地图 = 6001
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1131)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 6002
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1209)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000

	for n = 6003, 6008 do
		self.地图数据[n] = {
			npc = {},
			单位 = {},
			传送圈 = {}
		}
		self.地图玩家[n] = {}
		self.地图坐标[n] = 地图坐标类(1197)
		self.地图单位[n] = {}
		self.单位编号[n] = 1000
	end

	local 地图 = 6009
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1197)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000

	for n = 6010, 6019 do
		self.地图数据[n] = {
			npc = {},
			单位 = {},
			传送圈 = {}
		}
		self.地图玩家[n] = {}
		self.地图坐标[n] = 地图坐标类(1876)
		self.地图单位[n] = {}
		self.单位编号[n] = 1000
	end

	local 地图 = 6020
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1514)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 6021
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1204)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 6022
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1137)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 6023
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1111)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 6024
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1002)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 6025
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1001)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 6026
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1211)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 6027
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1070)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 6028
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1140)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 6029
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1116)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 6030
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1202)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	地图 = 6031
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1511)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	地图 = 6032
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1231)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	地图 = 6033
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1514)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	地图 = 6034
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1007)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	地图 = 6035
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1111)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 34470
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1173)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 34471
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1116)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 6040
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1111)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 6041
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1113)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 6042
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1112)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 6043
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1501)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 6044
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1506)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 6045
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1126)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 6046
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1507)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 5001
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1042)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 7001
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1237)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 7002
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1170)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 7003
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1412)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000
	local 地图 = 7004
	self.地图数据[地图] = {
		npc = {},
		单位 = {},
		传送圈 = {}
	}
	self.地图玩家[地图] = {}
	self.地图坐标[地图] = 地图坐标类(1041)
	self.地图单位[地图] = {}
	self.单位编号[地图] = 1000

	collectgarbage("collect")
end

function 地图处理类:npc传送(id, m, x, y)
	if 玩家数据[id].队伍 ~= 0 and 玩家数据[id].队长 == false then
		常规提示(id, "只有队长才可使用此项功能！")

		return
	end

	self:跳转地图(id, m, x, y)
end

function 地图处理类:门派传送(id, m)
	if 玩家数据[id].队伍 ~= 0 and 玩家数据[id].队长 == false then
		常规提示(id, "只有队长才可使用此项功能！")

		return
	end

	local cs = nil

	if m == "方寸山" then
		cs = {
			1135,
			72,
			63
		}
	elseif m == "女儿村" then
		cs = {
			1142,
			37,
			37
		}
	elseif m == "神木林" then
		cs = {
			1138,
			46,
			121
		}
	elseif m == "大唐官府" then
		cs = {
			1198,
			131,
			82
		}
	elseif m == "化生寺" then
		cs = {
			1002,
			7,
			88
		}
	elseif m == "阴曹地府" then
		cs = {
			1122,
			60,
			61
		}
	elseif m == "长安城" then
		cs = {
			1001,
			202,
			110
		}
	elseif m == "盘丝洞" then
		cs = {
			1513,
			174,
			31
		}
	elseif m == "无底洞" then
		cs = {
			1139,
			61,
			125
		}
	elseif m == "狮驼岭" then
		cs = {
			1131,
			109,
			77
		}
	elseif m == "魔王寨" then
		cs = {
			1512,
			76,
			29
		}
	elseif m == "普陀山" then
		cs = {
			1140,
			20,
			18
		}
	elseif m == "天宫" then
		cs = {
			1111,
			175,
			122
		}
	elseif m == "凌波城" then
		cs = {
			1150,
			33,
			67
		}
	elseif m == "五庄观" then
		cs = {
			1146,
			26,
			55
		}
	elseif m == "龙宫" then
		cs = {
			1116,
			71,
			77
		}
	elseif m == "天机城" then
		cs = {
			1250,
			63,
			92
		}
	elseif m == "女魃墓" then
		cs = {
			1249,
			51,
			44
		}
	elseif m == "花果山" then
		cs = {
			1251,
			69,
			30
		}
	elseif m == "九黎城" then
		cs = {
			2007,
			65,
			17
		}
	end

	if cs == nil or #cs == 0 then
		return
	else
		self:跳转地图(id, cs[1], cs[2], cs[3])
	end
end

function 地图处理类:明雷遇怪处理(连接id, id, 内容)
	local 标识 = 内容.标识
	local 序列 = 内容.序列

	if 取队长权限(id) == false then
		return
	elseif 自动遇怪[id] ~= nil or 自动捉鬼[id] ~= nil or 任务数据[标识] == nil or 自动挂机[id] ~= nil then
		return
	elseif 玩家数据[id].战斗 ~= 0 or 任务数据[标识].战斗 ~= nil then
		return
	elseif 任务数据[标识].类型 == 103 then
		战斗准备类:创建战斗(id, 100007, 标识)

		任务数据[标识].战斗 = true
	elseif 任务数据[标识].类型 == 202 then
		战斗准备类:创建战斗(id, 100019, 标识)

		任务数据[标识].战斗 = true
	elseif 任务数据[标识].类型 == 340 then
		战斗准备类:创建战斗(id, 100094, 标识)

		任务数据[标识].战斗 = true
	elseif 任务数据[标识].类型 == 359 then
		战斗准备类:创建战斗(id, 100136, 标识)

		任务数据[标识].战斗 = true
	elseif 任务数据[标识].类型 == 360 then
		战斗准备类:创建战斗(id, 100137, 标识)

		任务数据[标识].战斗 = true
	elseif 任务数据[标识].类型 == 361 then
		战斗准备类:创建战斗(id, 100138, 标识)

		任务数据[标识].战斗 = true
	end
end

function 地图处理类:数据处理(id, 序号, 数字id, 内容)
	内容.ip = nil

	if 序号 == 1001 then
		self:移动请求(id, 内容, 数字id)
	elseif 序号 == 1002 then
		self:移动坐标刷新(id, 数字id, 内容)
	elseif 序号 == 1002.1 then
		玩家数据[数字id].角色.数据.地图数据.y = 内容.y
		玩家数据[数字id].角色.数据.地图数据.x = 内容.x
		local 地图编号 = 玩家数据[数字id].角色.数据.地图数据.编号

		for i, v in pairs(self.地图玩家[地图编号]) do
			if i ~= 数字id then
				发送数据(玩家数据[i].连接id, 1012, {
					id = 数字id,
					x = 内容.x,
					y = 内容.y
				})
			end
		end
	elseif 序号 == 1001.1 then
		local dt = tonumber(内容.地图编号)

		玩家数据[数字id].角色:获取当前地图任务人物位置(玩家数据[数字id].连接id, dt, 数字id)
	elseif 序号 == 1003 then
		if 自动挂机[数字id] ~= nil or 玩家数据[数字id].队伍 ~= 0 and 玩家数据[数字id].队长 == false then
			return
		end

		local 目标 = 切换场景(内容.说明, 玩家数据[数字id].角色.数据.地图数据.编号)
		local 现在地图 = 取传送点(玩家数据[数字id].角色.数据.地图数据.编号)
		local 角色xy = {
			x = x,
			y = y
		}
		local 对方xy = {
			x = 0,
			y = 0
		}

		if 现在地图 == nil or 现在地图 ~= nil and 现在地图[内容.id] == nil or 现在地图 ~= nil and 现在地图[内容.id] ~= nil and 现在地图[内容.id].x == nil or 现在地图[内容.id].y == nil then
			常规提示(数字id, "#Y/传送阵位置错误")

			return
		end

		对方xy.y = 现在地图[内容.id].y
		对方xy.x = 现在地图[内容.id].x
		角色xy.y = 玩家数据[数字id].角色.数据.地图数据.y / 20
		角色xy.x = 玩家数据[数字id].角色.数据.地图数据.x / 20

		if 取两点距离(对方xy, 角色xy) >= 15 then
			常规提示(数字id, "#Y/传送阵和你的距离太远了吧")

			return
		else
			self:跳转地图(数字id, 目标[1], 目标[2].x, 目标[2].y)
		end
	elseif 序号 == 1004 then
		local 现在地图 = 玩家数据[数字id].角色.数据.地图数据.编号
		local 目标 = 内容.地图

		if 目标 == nil or 现在地图 == nil or self.地图单位[内容.地图] ~= nil and self.地图单位[内容.地图][内容.编号] == nil then
			常规提示(数字id, "#Y/你们距离太远了吧")

			return
		elseif 目标 ~= 现在地图 then
			常规提示(数字id, "#Y/你们距离太远了吧")

			return
		end

		local 角色xy = {
			x = x,
			y = y
		}
		local 对方xy = {
			x = 0,
			y = 0,
			y = self.地图单位[内容.地图][内容.编号].y,
			x = self.地图单位[内容.地图][内容.编号].x
		}
		角色xy.y = 玩家数据[数字id].角色.数据.地图数据.y / 20
		角色xy.x = 玩家数据[数字id].角色.数据.地图数据.x / 20

		if 取两点距离(对方xy, 角色xy) >= 500 then
			常规提示(数字id, "#Y/怪物和你的距离太远了吧")

			return
		else
			self:明雷遇怪处理(id, 数字id, 内容)
		end
	elseif 序号 == 1005 then
		if 内容.注释 == "庭院" then
			for i = 1, #房屋数据 do
				if 房屋数据[i].ID == 数字id and 扣除道具(数字id, 内容.名称, 1) then
					房屋数据[i].庭院装饰[#房屋数据[i].庭院装饰 + 1] = {
						x = 内容.x,
						y = 内容.y,
						名称 = 内容.名称,
						方向 = 内容.方向
					}

					for n, v in pairs(self.地图玩家[玩家数据[数字id].角色.数据.地图数据.编号]) do
						if n ~= id and self:取同一地图(玩家数据[数字id].角色.数据.地图数据.编号, id, n, 1) then
							发送数据(玩家数据[n].连接id, 1029, {
								房屋数据[i].庭院装饰,
								内容.注释
							})
						end
					end

					发送数据(玩家数据[数字id].连接id, 1029, {
						房屋数据[i].庭院装饰,
						内容.注释
					})
				end
			end
		elseif 内容.注释 == "室内" then
			for i = 1, #房屋数据 do
				if 房屋数据[i].ID == 数字id and 扣除道具(数字id, 内容.名称, 1) then
					房屋数据[i].室内装饰[#房屋数据[i].室内装饰 + 1] = {
						x = 内容.x,
						y = 内容.y,
						名称 = 内容.名称,
						方向 = 内容.方向
					}

					for n, v in pairs(self.地图玩家[玩家数据[数字id].角色.数据.地图数据.编号]) do
						if n ~= id and self:取同一地图(玩家数据[数字id].角色.数据.地图数据.编号, id, n, 1) then
							发送数据(玩家数据[n].连接id, 1029, {
								房屋数据[i].室内装饰,
								内容.注释
							})
						end
					end

					发送数据(玩家数据[数字id].连接id, 1029, {
						房屋数据[i].室内装饰,
						内容.注释
					})
				end
			end
		end
	elseif 序号 == 1006 then
		获取道具模式[数字id] = 1

		if 内容.注释 == "庭院" then
			for i = 1, #房屋数据 do
				if 房屋数据[i].ID == 数字id and 扣除道具(数字id, "如意符", 1) then
					local wp = 房屋数据[i].庭院装饰[内容.编号].名称

					快捷给道具(数字id, wp, 1)
					table.remove(房屋数据[i].庭院装饰, 内容.编号)

					for n, v in pairs(self.地图玩家[玩家数据[数字id].角色.数据.地图数据.编号]) do
						if n ~= id and self:取同一地图(玩家数据[数字id].角色.数据.地图数据.编号, id, n, 1) then
							发送数据(玩家数据[n].连接id, 1029, {
								房屋数据[i].庭院装饰,
								内容.注释
							})
						end
					end

					发送数据(玩家数据[数字id].连接id, 1029, {
						房屋数据[i].庭院装饰,
						内容.注释
					})
				end
			end
		elseif 内容.注释 == "室内" then
			for i = 1, #房屋数据 do
				if 房屋数据[i].ID == 数字id and 扣除道具(数字id, "如意符", 1) then
					local wp = 房屋数据[i].室内装饰[内容.编号].名称

					快捷给道具(数字id, wp, 1)
					table.remove(房屋数据[i].室内装饰, 内容.编号)

					for n, v in pairs(self.地图玩家[玩家数据[数字id].角色.数据.地图数据.编号]) do
						if n ~= id and self:取同一地图(玩家数据[数字id].角色.数据.地图数据.编号, id, n, 1) then
							发送数据(玩家数据[n].连接id, 1029, {
								房屋数据[i].室内装饰,
								内容.注释
							})
						end
					end

					发送数据(玩家数据[数字id].连接id, 1029, {
						房屋数据[i].室内装饰,
						内容.注释
					})
				end
			end
		end

		获取道具模式[数字id] = nil
	end
end

function 地图处理类:跳转地图(数字id, 地图编号, x, y, 强制)
	if 玩家数据[数字id].队伍 ~= 0 and 玩家数据[数字id].队长 == false then
		return 0
	end

	if 玩家数据[数字id].战斗 ~= 0 and 强制 == nil then
		return
	end

	if 玩家数据[数字id].摊位数据 ~= nil then
		return
	end

	local x1 = x * 20
	local y1 = y * 20
	玩家数据[数字id].角色.数据.地图数据.y = y1
	玩家数据[数字id].角色.数据.地图数据.x = x1

	self:移除玩家(数字id)

	玩家数据[数字id].角色.数据.地图数据.编号 = 地图编号

	发送数据(玩家数据[数字id].连接id, 1005, {
		地图编号,
		x,
		y
	})

	if 天气地图[tostring(地图编号)] ~= nil then
		发送数据(玩家数据[数字id].连接id, 43.1, {
			提示 = true,
			天气 = 地区天气[天气地图[tostring(地图编号)]]
		})
	end

	self:加入玩家(数字id, 地图编号, x1, y1)

	if 玩家数据[数字id].队伍 ~= 0 and 玩家数据[数字id].队长 then
		local 队伍id = 玩家数据[数字id].队伍

		for n = 2, #队伍数据[队伍id].成员数据 do
			if 队伍处理类:取是否助战(队伍id, n) == 0 then
				local 队员id = 队伍数据[队伍id].成员数据[n]
				玩家数据[队员id].角色.数据.地图数据.y = y1
				玩家数据[队员id].角色.数据.地图数据.x = x1

				self:移除玩家(队员id)

				玩家数据[队员id].角色.数据.地图数据.编号 = 地图编号

				发送数据(玩家数据[队员id].连接id, 1005, {
					地图编号,
					x,
					y
				})

				if 天气地图[tostring(地图编号)] ~= nil then
					发送数据(玩家数据[队员id].连接id, 43.1, {
						提示 = true,
						天气 = 地区天气[天气地图[tostring(地图编号)]]
					})
				end

				self:加入玩家(队员id, 地图编号, x1, y1)
			end
		end
	end
end

function 地图处理类:更改模型(id, 模型, 类型)
	local 地图编号 = 玩家数据[id].角色.数据.地图数据.编号

	for n, v in pairs(self.地图玩家[地图编号]) do
		if n ~= id and self:取同一地图(地图编号, id, n, 1) then
			if type(模型) == "string" then
				发送数据(玩家数据[n].连接id, 1024, {
					id = id,
					变身 = 模型
				})
			else
				发送数据(玩家数据[n].连接id, 1024, {
					id = id,
					变身 = 模型[1],
					变异 = 模型[2]
				})
			end
		end
	end
end

function 地图处理类:重置比武大会玩家()
	比武大会数据 = {}
	local 分组 = ""

	for n = 6003, 6008 do
		分组 = 取地图名称(n)

		if 比武大会数据[分组] == nil then
			比武大会数据[分组] = {}
		end

		for i, v in pairs(self.地图玩家[n]) do
			玩家数据[i].比武保护期 = 0
			比武大会数据[分组][i] = {
				奖励 = false,
				连胜次数 = 0,
				积分 = 0,
				id = i,
				等级 = 玩家数据[i].角色.数据.等级,
				名称 = 玩家数据[i].角色.数据.名称,
				门派 = 玩家数据[i].角色.数据.门派,
				账号 = 玩家数据[i].账号,
				奖励 = true
			}
		end
	end
end

function 地图处理类:比武添加仙玉()
	for i, v in pairs(self.地图玩家[6003]) do
		添加仙玉(1, 玩家数据[i].账号, i, "英雄比武大会")
		常规提示(i, "刻晴奖励参与比武大会的英雄每秒获得1仙玉的奖励")
	end
end

function 地图处理类:重置首席争霸赛()
	首席争霸数据 = {}
	首席排名 = {}
	local 门派 = ""
	local 人数 = 0

	for i, v in pairs(self.地图玩家[6009]) do
		门派 = 玩家数据[i].角色.数据.门派

		if 首席争霸数据[门派] == nil then
			首席争霸数据[门派] = {}
		end

		首席争霸数据[门派][i] = {
			奖励 = false,
			积分 = 0,
			连胜次数 = 0,
			id = i,
			等级 = 玩家数据[i].角色.数据.等级,
			名称 = 玩家数据[i].角色.数据.名称,
			模型 = 玩家数据[i].角色.数据.模型,
			染色组 = 玩家数据[i].角色.数据.染色组,
			染色方案 = 玩家数据[i].角色.数据.染色方案
		}

		if 玩家数据[i].角色.数据.装备[3] ~= nil and 玩家数据[i].道具.数据[玩家数据[i].角色.数据.装备[3]] ~= nil then
			首席争霸数据[门派][i].武器 = 玩家数据[i].道具.数据[玩家数据[i].角色.数据.装备[3]].名称
			首席争霸数据[门派][i].武器等级 = 玩家数据[i].道具.数据[玩家数据[i].角色.数据.装备[3]].级别限制
			首席争霸数据[门派][i].武器染色方案 = 玩家数据[i].道具.数据[玩家数据[i].角色.数据.装备[3]].染色方案
			首席争霸数据[门派][i].武器染色组 = 玩家数据[i].道具.数据[玩家数据[i].角色.数据.装备[3]].染色组
		end

		常规提示(i, "你当前的首席积分为0分，每战胜一名玩家可获得5点积分")
	end

	for k, v in pairs(首席争霸数据) do
		local 人数 = 0

		for i, n in pairs(v) do
			if 玩家数据[i] ~= nil then
				人数 = 人数 + 1
			end
		end

		if 人数 == 1 then
			结束首席争霸(1, k)
		end
	end
end

function 地图处理类:玩家是否飞行(id, 逻辑)
	local 地图编号 = 玩家数据[id].角色.数据.地图数据.编号

	发送数据(玩家数据[id].连接id, 60.1, {
		飞行中 = 逻辑
	})

	for n, v in pairs(self.地图玩家[地图编号]) do
		if n ~= id and 玩家数据[n] ~= nil and self:取同一地图(地图编号, id, n, 1) then
			发送数据(玩家数据[n].连接id, 60.2, {
				id = id,
				逻辑 = 逻辑
			})
		end
	end
end

function 地图处理类:玩家是否加速(id, 逻辑)
	local 地图编号 = 玩家数据[id].角色.数据.地图数据.编号

	发送数据(玩家数据[id].连接id, 133.1, 逻辑)

	for n, v in pairs(self.地图玩家[地图编号]) do
		if n ~= id and 玩家数据[n] ~= nil and self:取同一地图(地图编号, id, n, 1) then
			发送数据(玩家数据[n].连接id, 133.2, {
				id = id,
				逻辑 = 逻辑
			})
		end
	end
end

function 地图处理类:重置坐标(id, x, y)
	玩家数据[id].角色.数据.地图数据.y = y
	玩家数据[id].角色.数据.地图数据.x = x

	发送数据(玩家数据[id].连接id, 1011, {
		x = x,
		y = y
	})

	local 地图编号 = 玩家数据[id].角色.数据.地图数据.编号

	for i, v in pairs(self.地图玩家[地图编号]) do
		if i ~= id then
			发送数据(玩家数据[i].连接id, 1012, {
				id = id,
				x = x,
				y = y
			})
		end
	end
end

取队长移动速度 = function(id)
	local 月卡 = false
	local 坐骑锦衣 = false

	if 玩家数据[id].角色.数据.移速加成 then
		月卡 = true
	end

	if 玩家数据[id].角色.数据.坐骑 ~= nil or 玩家数据[id].角色.数据.锦衣[1] ~= nil then
		坐骑锦衣 = true
	end

	return {
		坐骑锦衣,
		月卡
	}
end

function 地图处理类:移动坐标刷新(id, 数字id, 内容)
	if 玩家数据[数字id].队伍 == 0 or 玩家数据[数字id].队伍 ~= 0 and 玩家数据[数字id].队长 then
		玩家数据[数字id].角色.数据.地图数据.y = 内容.y
		玩家数据[数字id].角色.数据.地图数据.x = 内容.x
	end

	local 地图 = 玩家数据[数字id].角色.数据.地图数据.编号

	if 玩家数据[数字id].队伍 ~= 0 and 玩家数据[数字id].队长 and 玩家数据[数字id].移动数据.移动目标 ~= nil then
		local 角色xy = {
			x = 内容.x,
			y = 内容.y
		}
		local 对方xy = {
			x = 0,
			y = 0
		}
		local 真实队友 = 1

		for n = 2, #队伍数据[玩家数据[数字id].队伍].成员数据 do
			local 队员id = 队伍数据[玩家数据[数字id].队伍].成员数据[n]

			if 队员id ~= 数字id then
				真实队友 = 真实队友 + 1
				对方xy.y = 玩家数据[队员id].角色.数据.地图数据.y
				对方xy.x = 玩家数据[队员id].角色.数据.地图数据.x

				if 取两点距离(角色xy, 对方xy) >= self.队伍距离 * (真实队友 - 1) and 玩家数据[数字id].移动数据[真实队友] == false then
					玩家数据[数字id].移动数据[真实队友] = true
					local 临时数据 = {
						x = 玩家数据[数字id].移动数据.移动目标.x,
						y = 玩家数据[数字id].移动数据.移动目标.y,
						距离 = self.队伍距离 * (真实队友 - 1),
						数字id = 队员id,
						速度 = 取队长移动速度(数字id)
					}
					玩家数据[队员id].队长速度 = true

					发送数据(玩家数据[队员id].连接id, 1001, 临时数据)

					local 地图编号 = 玩家数据[数字id].角色.数据.地图数据.编号

					for i, v in pairs(self.地图玩家[地图]) do
						if i ~= 队员id and self:取同一地图(地图, 队员id, i, 1) then
							发送数据(玩家数据[i].连接id, 1008, {
								数字id = 队员id,
								路径 = 临时数据
							})
						end
					end
				end
			end
		end
	end

	if self.遇怪地图[地图] ~= nil and 取队长权限(数字id) then
		if 玩家数据[数字id].遇怪时间 == nil then
			玩家数据[id].遇怪时间 = os.time() + 取随机数(10, 20)
		end

		if 玩家数据[数字id].遇怪时间 <= os.time() and self:遇怪条件检测(地图, 数字id) then
			if 取随机数(1, 10000) <= 暗雷遇神兽几率 then
				战斗准备类:创建战斗(数字id, 100225, 0)
				常规提示(数字id, "#Y你遇到神兽啦!!!")
			else
				战斗准备类:创建战斗(数字id, 100001, 0)
			end
		else
			self:官职情报收集检测(地图, 数字id)
		end
	end

	if 玩家数据[数字id].角色:取任务(111) ~= 0 and 任务数据[玩家数据[数字id].角色:取任务(111)].分类 == 2 and 取门派巡逻地图(玩家数据[数字id].角色.数据.门派, 地图) and 取随机数() <= 50 and (玩家数据[数字id].战斗 == nil or 玩家数据[数字id].战斗 == 0) then
		战斗准备类:创建战斗(数字id, 100015, 玩家数据[数字id].角色:取任务(111))
	end

	if 玩家数据[数字id].角色:取任务(301) ~= 0 and 任务数据[玩家数据[数字id].角色:取任务(301)].分类 == 4 and 取随机数() <= 50 and (玩家数据[数字id].战斗 == nil or 玩家数据[数字id].战斗 == 0) then
		战斗准备类:创建战斗(数字id, 100034, 玩家数据[数字id].角色:取任务(301))
	end

	if 玩家数据[数字id].角色:取任务(302) ~= 0 and 任务数据[玩家数据[数字id].角色:取任务(302)].分类 == 4 and 取随机数() <= 50 and (玩家数据[数字id].战斗 == nil or 玩家数据[数字id].战斗 == 0) then
		战斗准备类:创建战斗(数字id, 100035, 玩家数据[数字id].角色:取任务(302))
	end

	if 地图 == 6031 then
		if 玩家数据[数字id].角色:取任务(182) ~= 0 and 取随机数() <= 5 and (玩家数据[数字id].战斗 == nil or 玩家数据[数字id].战斗 == 0) then
			战斗准备类:创建战斗(数字id, 100147, 玩家数据[数字id].角色:取任务(182))
		end

		if 玩家数据[数字id].角色:取任务(181) ~= 0 and 取随机数() <= 50 and (玩家数据[数字id].战斗 == nil or 玩家数据[数字id].战斗 == 0) then
			local rwid = 玩家数据[数字id].角色:取任务(181)

			if math.abs(玩家数据[数字id].角色.数据.地图数据.x / 20 - 任务数据[rwid].x) <= 10 and math.abs(玩家数据[数字id].角色.数据.地图数据.y / 20 - 任务数据[rwid].y) <= 10 then
				local 临时数据 = {
					模型 = 玩家数据[数字id].角色.数据.模型,
					名称 = 玩家数据[数字id].角色.数据.名称,
					对话 = "这附近的确杂草横生，好，开始清理吧！\n#Y(蟠桃园锄树清草，可得讲究力道，增之一分则太多，减之一分则太少。请选择你要使用的力道。)",
					选项 = {
						"一分力道",
						"二分力道",
						"三分力道",
						"四分力道",
						"五分力道"
					}
				}
				玩家数据[数字id].角色.数据.对话类型 = "大闹除草"

				发送数据(玩家数据[数字id].连接id, 1501, 临时数据)
			end
		end
	end
end

function 地图处理类:官职情报收集检测(地图, id)
	if 地图 == 1110 or 地图 == 1514 or 地图 == 1174 or 地图 == 1091 or 地图 == 1173 then
		local 随机值 = 取随机数()

		if 玩家数据[id].角色:取任务(110) ~= 0 and 任务数据[玩家数据[id].角色:取任务(110)].分类 == 3 and 任务数据[玩家数据[id].角色:取任务(110)].情报 == false and 随机值 <= 20 then
			战斗准备类:创建战斗(id, 100014, 玩家数据[id].角色:取任务(110))
		end
	end
end

function 地图处理类:遇怪条件检测(地图, id)
	if 地图 >= 1004 and 地图 <= 1009 then
		return false
	elseif 地图 == 1090 then
		return false
	elseif 玩家数据[id].战斗 ~= nil and 玩家数据[id].战斗 ~= 0 then
		return false
	elseif 玩家数据[id].角色:取任务(110) ~= 0 and 任务数据[玩家数据[id].角色:取任务(110)].分类 == 3 then
		return false
	elseif 玩家数据[id].角色:取任务(111) ~= 0 and 任务数据[玩家数据[id].角色:取任务(111)].分类 == 2 then
		return false
	end

	local 场景等级 = 取场景等级(地图)

	if 场景等级 == nil then
		return false
	elseif 自动挂机[id] ~= nil then
		return false
	elseif 玩家数据[id].角色:取任务(9) ~= 0 then
		return false
	elseif 玩家数据[id].战斗 ~= nil and 玩家数据[id].战斗 ~= 0 then
		return false
	end

	return true
end

function 地图处理类:比较距离(id, 对方id, 距离)
	if 玩家数据[id].角色.数据.地图数据.编号 ~= 玩家数据[对方id].角色.数据.地图数据.编号 then
		return false
	elseif 距离 < 取两点距离(玩家数据[id].角色.数据.地图数据, 玩家数据[对方id].角色.数据.地图数据) then
		return false
	end

	return true
end

function 地图处理类:取移动限制(id)
	if id == nil or 玩家数据[id] == nil then
		return true
	end

	if 玩家数据[id].队伍 ~= 0 and 玩家数据[id].队长 == false then
		return true
	elseif 玩家数据[id].摊位数据 ~= nil then
		return true
	elseif 自动遇怪[id] ~= nil then
		return true
	elseif 自动捉鬼[id] ~= nil then
		return true
	end

	return false
end

function 地图处理类:移动请求(id, 内容, 数字id, 挂机)
	if self:取移动限制(数字id) then
		return
	else
		内容.距离 = 0
	end

	if 玩家数据[数字id].队伍 ~= 0 then
		玩家数据[数字id].移动数据 = {}

		for n = 1, #队伍数据[玩家数据[数字id].队伍].成员数据 do
			玩家数据[数字id].移动数据[n] = false
		end
	elseif 玩家数据[数字id].队长速度 == true then
		发送数据(玩家数据[数字id].连接id, 1007.2)

		玩家数据[数字id].队长速度 = nil
	end

	if 挂机 == true then
		发送数据(玩家数据[数字id].连接id, 1007.1, 内容)
	end

	玩家数据[数字id].移动数据.移动目标 = 内容
	local 地图编号 = 玩家数据[数字id].角色.数据.地图数据.编号

	for n, v in pairs(self.地图玩家[地图编号]) do
		if n ~= 数字id and 玩家数据[n] ~= nil and self:取同一地图(地图编号, 数字id, n, 1) then
			发送数据(玩家数据[n].连接id, 1008, {
				数字id = 数字id,
				路径 = 内容
			})
		end
	end
end

function 地图处理类:更新(dt)
end

function 地图处理类:移除玩家(id)
	local 地图编号 = 玩家数据[id].角色.数据.地图数据.编号

	for n, v in pairs(self.地图玩家[地图编号]) do
		if n ~= id and self:取同一地图(地图编号, id, n, 1) then
			发送数据(玩家数据[n].连接id, 1007, {
				id = id
			})
		end
	end

	self.地图玩家[地图编号][id] = nil
end

function 地图处理类:更改染色(id, 染色组, 方案)
	local 地图编号 = 玩家数据[id].角色.数据.地图数据.编号

	for n, v in pairs(self.地图玩家[地图编号]) do
		if n ~= id and self:取同一地图(地图编号, id, n, 1) then
			发送数据(玩家数据[n].连接id, 1013, {
				id = id,
				染色组 = 染色组,
				染色方案 = 方案
			})
		end
	end
end

function 地图处理类:更改PK(id, 开关)
	local 地图编号 = 玩家数据[id].角色.数据.地图数据.编号

	for n, v in pairs(self.地图玩家[地图编号]) do
		if n ~= id and self:取同一地图(地图编号, id, n, 1) then
			发送数据(玩家数据[n].连接id, 1023, {
				id = id,
				开关 = 开关
			})
		end
	end
end

function 地图处理类:更改强PK(id, 开关)
	local 地图编号 = 玩家数据[id].角色.数据.地图数据.编号

	for n, v in pairs(self.地图玩家[地图编号]) do
		if n ~= id and self:取同一地图(地图编号, id, n, 1) then
			发送数据(玩家数据[n].连接id, 1025, {
				id = id,
				开关 = 开关
			})
		end
	end
end

function 地图处理类:更新武器(id, 武器)
	local 地图编号 = 玩家数据[id].角色.数据.地图数据.编号
	local 副武器 = nil

	if 玩家数据[id].角色.数据.模型 == "影精灵" and 玩家数据[id].角色.数据.装备 ~= nil and 玩家数据[id].角色.数据.装备[4] ~= nil and 玩家数据[id].道具.数据[玩家数据[id].角色.数据.装备[4]].子类 == 911 then
		副武器 = 玩家数据[id].道具.数据[玩家数据[id].角色.数据.装备[4]]
	end

	for n, v in pairs(self.地图玩家[地图编号]) do
		if n ~= id and self:取同一地图(地图编号, id, n, 1) then
			发送数据(玩家数据[n].连接id, 1009, {
				id = id,
				武器 = 武器,
				副武器 = 副武器
			})
		end
	end
end

function 地图处理类:更新锦衣(id, 锦衣)
	local 地图编号 = 玩家数据[id].角色.数据.地图数据.编号

	for n, v in pairs(self.地图玩家[地图编号]) do
		if n ~= id and self:取同一地图(地图编号, id, n, 1) then
			发送数据(玩家数据[n].连接id, 1014, {
				id = id,
				锦衣 = 锦衣
			})
		end
	end
end

function 地图处理类:更新坐骑(id, 坐骑)
	local 地图编号 = 玩家数据[id].角色.数据.地图数据.编号

	for n, v in pairs(self.地图玩家[地图编号]) do
		if n ~= id and self:取同一地图(地图编号, id, n, 1) then
			发送数据(玩家数据[n].连接id, 1019, {
				id = id,
				坐骑 = 坐骑
			})
		end
	end
end

function 地图处理类:更新称谓(id, 称谓ID)
	local 地图编号 = 玩家数据[id].角色.数据.地图数据.编号

	if 玩家数据[id].角色.数据.称谓 ~= nil and 称谓ID ~= nil and 玩家数据[id].角色.数据.称谓[math.ceil(称谓ID)] ~= nil then
		if 玩家数据[id].角色.数据.当前称谓 == "武神坛冠军" or 玩家数据[id].角色.数据.当前称谓 == "武神坛亚军" or 玩家数据[id].角色.数据.当前称谓 == "武神坛季军" then
			玩家数据[id].角色.数据.力量 = 玩家数据[id].角色.数据.力量 - 5
			玩家数据[id].角色.数据.魔力 = 玩家数据[id].角色.数据.魔力 - 5
			玩家数据[id].角色.数据.体质 = 玩家数据[id].角色.数据.体质 - 5
			玩家数据[id].角色.数据.耐力 = 玩家数据[id].角色.数据.耐力 - 5
			玩家数据[id].角色.数据.敏捷 = 玩家数据[id].角色.数据.敏捷 - 5
		end

		玩家数据[id].角色.数据.当前称谓 = 玩家数据[id].角色.数据.称谓[math.ceil(称谓ID)]

		if 玩家数据[id].角色.数据.当前称谓 == "武神坛冠军" or 玩家数据[id].角色.数据.当前称谓 == "武神坛亚军" or 玩家数据[id].角色.数据.当前称谓 == "武神坛季军" then
			玩家数据[id].角色.数据.力量 = 玩家数据[id].角色.数据.力量 + 5
			玩家数据[id].角色.数据.魔力 = 玩家数据[id].角色.数据.魔力 + 5
			玩家数据[id].角色.数据.体质 = 玩家数据[id].角色.数据.体质 + 5
			玩家数据[id].角色.数据.耐力 = 玩家数据[id].角色.数据.耐力 + 5
			玩家数据[id].角色.数据.敏捷 = 玩家数据[id].角色.数据.敏捷 + 5
		end
	else
		if 玩家数据[id].角色.数据.当前称谓 == "武神坛冠军" or 玩家数据[id].角色.数据.当前称谓 == "武神坛亚军" or 玩家数据[id].角色.数据.当前称谓 == "武神坛季军" then
			玩家数据[id].角色.数据.力量 = 玩家数据[id].角色.数据.力量 - 5
			玩家数据[id].角色.数据.魔力 = 玩家数据[id].角色.数据.魔力 - 5
			玩家数据[id].角色.数据.体质 = 玩家数据[id].角色.数据.体质 - 5
			玩家数据[id].角色.数据.耐力 = 玩家数据[id].角色.数据.耐力 - 5
			玩家数据[id].角色.数据.敏捷 = 玩家数据[id].角色.数据.敏捷 - 5
		end

		玩家数据[id].角色.数据.当前称谓 = ""
	end

	玩家数据[id].角色:刷新信息()
	发送数据(玩家数据[id].连接id, 33, 玩家数据[id].角色:取总数据(1))

	for n, v in pairs(self.地图玩家[地图编号]) do
		if n ~= id and self:取同一地图(地图编号, id, n, 1) then
			发送数据(玩家数据[n].连接id, 1020, {
				id = id,
				当前称谓 = 玩家数据[id].角色.数据.当前称谓
			})
		end
	end
end

function 地图处理类:设置战斗开关(id, 逻辑)
	local 地图编号 = 玩家数据[id].角色.数据.地图数据.编号

	for n, v in pairs(self.地图玩家[地图编号]) do
		if n ~= id and 玩家数据[n] ~= nil and self:取同一地图(地图编号, id, n, 1) then
			发送数据(玩家数据[n].连接id, 4014, {
				id = id,
				逻辑 = 逻辑
			})
		end
	end
end

function 地图处理类:更改队伍图标(id, 逻辑)
	local 地图编号 = 玩家数据[id].角色.数据.地图数据.编号

	for n, v in pairs(self.地图玩家[地图编号]) do
		if n ~= id and self:取同一地图(地图编号, id, n, 1) then
			发送数据(玩家数据[n].连接id, 4007, {
				id = id,
				逻辑 = 逻辑
			})
		end
	end
end

function 地图处理类:加入动画(id, 地图编号, x, y, 类型)
	local 角色xy = {
		x = x,
		y = y
	}
	local 对方xy = {
		x = 0,
		y = 0
	}

	for n, v in pairs(self.地图玩家[地图编号]) do
		if n ~= id and self:取同一地图(地图编号, id, n, 1) then
			对方xy.y = 玩家数据[n].角色.数据.地图数据.y
			对方xy.x = 玩家数据[n].角色.数据.地图数据.x

			if 取两点距离(角色xy, 对方xy) <= 1500 then
				发送数据(玩家数据[n].连接id, 1010, {
					id = id,
					类型 = 类型
				})
			end
		end
	end
end

function 地图处理类:删除单位(地图, 编号)
	if 地图 == nil or 编号 == nil or self.地图单位[地图] == nil then
		if 地图 == nil then
			地图 = "异常地图"
		end

		错误日志[#错误日志] = {
			时间 = os.time(),
			记录 = "地图异常数据:" .. 地图
		}

		return
	end

	self.地图单位[地图][编号] = nil

	for n, v in pairs(self.地图玩家[地图]) do
		发送数据(玩家数据[v].连接id, 1016, {
			编号 = 编号
		})
	end
end

function 地图处理类:添加单位(id)
	local 地图 = 任务数据[id].地图编号
	local 编号 = 0

	for n, v in pairs(self.地图单位[地图]) do
		if self.地图单位[地图][n] == nil then
			编号 = n
		end
	end

	for n = 1000, self.单位编号[地图] do
		if 编号 == 0 and self.地图单位[地图][n] == nil then
			编号 = n
		end
	end

	if 编号 == 0 then
		self.单位编号[地图] = self.单位编号[地图] + 1
		编号 = self.单位编号[地图]
	end

	local 领取人的ID = 0

	if 任务数据[id] ~= nil and 任务数据[id].领取人id ~= nil and #任务数据[id].领取人id > 0 then
		领取人的ID = 任务数据[id].领取人id
	end

	self.地图单位[地图][编号] = {
		名称 = 任务数据[id].名称,
		模型 = 任务数据[id].模型,
		编号 = 编号,
		x = 任务数据[id].x,
		y = 任务数据[id].y,
		地图 = 地图,
		变异 = 任务数据[id].变异,
		称谓 = 任务数据[id].称谓,
		事件 = 任务数据[id].事件,
		武器 = 任务数据[id].武器,
		类型 = 任务数据[id].类型,
		行走开关 = 任务数据[id].行走开关,
		国境怪物移动 = 任务数据[id].国境怪物移动,
		境外怪物移动 = 任务数据[id].境外怪物移动,
		武器染色方案 = 任务数据[id].武器染色方案,
		武器染色组 = 任务数据[id].武器染色组,
		染色方案 = 任务数据[id].染色方案,
		染色组 = 任务数据[id].染色组,
		锦衣 = 任务数据[id].锦衣,
		方向 = 任务数据[id].方向,
		显示饰品 = 任务数据[id].显示饰品,
		id = id,
		领取人id = 领取人的ID,
		副本id = 任务数据[id].副本id
	}

	if self.地图单位[地图][编号].事件 == nil then
		self.地图单位[地图][编号].事件 = "单位"
	end

	任务数据[id].单位编号 = 编号

	for n, v in pairs(self.地图玩家[地图]) do
		if self:取同一地图(地图, v, self.地图单位[地图][编号], 2) then
			发送数据(玩家数据[v].连接id, 1015, self.地图单位[地图][编号])
		end
	end
end

function 地图处理类:批量添加单位(id)
	local 地图 = 任务数据[id].地图编号
	local 编号 = 0

	for n, v in pairs(self.地图单位[地图]) do
		if self.地图单位[地图][n] == nil then
			编号 = n
		end
	end

	for n = 1000, self.单位编号[地图] do
		if 编号 == 0 and self.地图单位[地图][n] == nil then
			编号 = n
		end
	end

	if 编号 == 0 then
		self.单位编号[地图] = self.单位编号[地图] + 1
		编号 = self.单位编号[地图]
	end

	local 领取人的ID = 0

	if 任务数据[id] ~= nil and 任务数据[id].领取人id ~= nil and #任务数据[id].领取人id > 0 then
		领取人的ID = 任务数据[id].领取人id
	end

	self.地图单位[地图][编号] = {
		名称 = 任务数据[id].名称,
		模型 = 任务数据[id].模型,
		编号 = 编号,
		x = 任务数据[id].x,
		y = 任务数据[id].y,
		地图 = 地图,
		变异 = 任务数据[id].变异,
		称谓 = 任务数据[id].称谓,
		事件 = 任务数据[id].事件,
		武器 = 任务数据[id].武器,
		类型 = 任务数据[id].类型,
		行走开关 = 任务数据[id].行走开关,
		国境怪物移动 = 任务数据[id].国境怪物移动,
		境外怪物移动 = 任务数据[id].境外怪物移动,
		武器染色方案 = 任务数据[id].武器染色方案,
		武器染色组 = 任务数据[id].武器染色组,
		染色方案 = 任务数据[id].染色方案,
		染色组 = 任务数据[id].染色组,
		锦衣 = 任务数据[id].锦衣,
		方向 = 任务数据[id].方向,
		显示饰品 = 任务数据[id].显示饰品,
		id = id,
		领取人id = 领取人的ID,
		副本id = 任务数据[id].副本id
	}

	if self.地图单位[地图][编号].事件 == nil then
		self.地图单位[地图][编号].事件 = "单位"
	end

	任务数据[id].单位编号 = 编号

	return self.地图单位[地图][编号]
end

function 地图处理类:更改怪物模型(任务id)
	local 编号 = 0
	local 地图 = 任务数据[任务id].地图编号

	for n, v in pairs(self.地图单位[地图]) do
		if 任务数据[任务id].单位编号 == n then
			self.地图单位[地图][n].模型 = 任务数据[任务id].模型

			for i, v in pairs(self.地图玩家[地图]) do
				if self:取同一地图(地图, v, self.地图单位[地图][编号], 2) then
					发送数据(玩家数据[v].连接id, 1015.1, self.地图单位[地图][n])
				end
			end

			return
		end
	end
end

function 地图处理类:设置玩家摊位(id, 名称)
	local 地图编号 = 玩家数据[id].角色.数据.地图数据.编号

	for n, v in pairs(self.地图玩家[地图编号]) do
		if n ~= id and self:取同一地图(地图编号, id, n, 1) then
			发送数据(玩家数据[n].连接id, 3519, {
				id = id,
				名称 = 名称
			})
		end
	end
end

function 地图处理类:取消玩家摊位(id)
	local 地图编号 = 玩家数据[id].角色.数据.地图数据.编号

	for n, v in pairs(self.地图玩家[地图编号]) do
		if n ~= id and self:取同一地图(地图编号, id, n, 1) then
			发送数据(玩家数据[n].连接id, 3519, {
				id = id
			})
		end
	end
end

function 地图处理类:当前消息广播(数据, 名称, 内容, 超链, id)
	for n, v in pairs(self.地图玩家[数据.编号]) do
		if self:取同一地图(数据.编号, id, n, 1) then
			if 取两点距离(数据, 玩家数据[n].角色.数据.地图数据) <= 1500 then
				发送数据(玩家数据[n].连接id, 38, {
					频道 = "dq",
					内容 = "[" .. 名称 .. "]" .. 内容,
					超链 = 超链
				})
			end

			if n ~= id and 玩家数据[n].战斗 == 0 and 取两点距离(数据, 玩家数据[n].角色.数据.地图数据) <= 1000 then
				发送数据(玩家数据[n].连接id, 1018, {
					id = id,
					文本 = 内容
				})
			end
		end
	end
end

function 地图处理类:清除地图玩家(编号, 目标, x, y)
	for n, v in pairs(self.地图玩家[编号]) do
		self:跳转地图(n, 目标, x, y)
	end
end

function 地图处理类:当前消息广播1(编号, 内容)
	for n, v in pairs(self.地图玩家[编号]) do
		发送数据(玩家数据[n].连接id, 38, {
			频道 = "dq",
			内容 = 内容
		})
	end
end

function 地图处理类:当前消息广播2(编号, 内容, 任务id)
	for n, v in pairs(self.地图玩家[编号]) do
		if 玩家数据[n].角色:取任务(130) ~= 0 and 玩家数据[n].角色:取任务(130) == 任务id then
			发送数据(玩家数据[n].连接id, 38, {
				频道 = "dq",
				内容 = 内容
			})
		end
	end
end

function 地图处理类:取地图人数(地图编号)
	local 数量 = 0

	for n, v in pairs(self.地图玩家[地图编号]) do
		数量 = 数量 + 1
	end

	return 数量
end

function 地图处理类:取同一地图(地图, id, id1, 类型)
	local 编号 = 0
	local 编号1 = 0

	if 地图 >= 6000 and 地图 <= 6050 or 地图 >= 7000 and 地图 <= 7100 or 地图 == 34471 then
		if 类型 == 1 then
			if 地图 <= 6002 and 玩家数据[id].角色:取任务(120) == 玩家数据[id1].角色:取任务(120) then
				return true
			elseif 地图 >= 6003 and 地图 <= 6008 then
				return true
			elseif 地图 == 6009 and 玩家数据[id].角色.数据.门派 == 玩家数据[id1].角色.数据.门派 then
				return true
			elseif 地图 >= 6010 and 地图 <= 6019 then
				return true
			elseif 地图 == 6020 and 帮派竞赛[编号].分组 == 帮派竞赛[编号1].分组 then
				return true
			elseif 地图 >= 6021 and 地图 <= 6023 and 玩家数据[id].角色:取任务(130) == 玩家数据[id1].角色:取任务(130) then
				return true
			elseif 地图 >= 6024 and 地图 <= 6026 and 玩家数据[id].角色:取任务(150) == 玩家数据[id1].角色:取任务(150) then
				return true
			elseif 地图 >= 6027 and 地图 <= 6030 and 玩家数据[id].角色:取任务(160) == 玩家数据[id1].角色:取任务(160) then
				return true
			elseif 地图 >= 6031 and 地图 <= 6035 and 玩家数据[id].角色:取任务(180) == 玩家数据[id1].角色:取任务(180) then
				return true
			elseif 地图 >= 6036 and 地图 <= 6039 and 玩家数据[id].角色:取任务(191) == 玩家数据[id1].角色:取任务(191) then
				return true
			elseif 地图 >= 7001 and 地图 <= 7004 and 玩家数据[id].角色:取任务(7001) == 玩家数据[id1].角色:取任务(7001) then
				return true
			elseif 地图 == 34471 and 玩家数据[id].角色:取任务(34471) == 玩家数据[id1].角色:取任务(34471) then
				return true
			else
				return false
			end
		elseif 地图 <= 6002 then
			if 玩家数据[id].角色:取任务(120) ~= 0 and 任务数据[玩家数据[id].角色:取任务(120)] ~= nil and 任务数据[玩家数据[id].角色:取任务(120)].副本id == 任务数据[id1.id].副本id then
				return true
			else
				return false
			end
		elseif 地图 >= 6003 and 地图 <= 6008 then
			return true
		elseif 地图 == 6009 and 玩家数据[id].角色.数据.门派 == 玩家数据[id1].角色.数据.门派 then
			return true
		elseif 地图 >= 6010 and 地图 <= 6019 then
			return true
		elseif 地图 == 6020 and 帮派竞赛[编号].分组 == 帮派竞赛[编号1].分组 then
			return true
		elseif 地图 >= 6021 and 地图 <= 6023 then
			if 玩家数据[id].角色:取任务(130) ~= 0 and 任务数据[玩家数据[id].角色:取任务(130)] ~= nil and 任务数据[玩家数据[id].角色:取任务(130)].副本id == 任务数据[id1.id].副本id then
				return true
			else
				return false
			end
		elseif 地图 >= 6024 and 地图 <= 6026 then
			if 玩家数据[id].角色:取任务(150) ~= 0 and 任务数据[玩家数据[id].角色:取任务(150)] ~= nil and 任务数据[玩家数据[id].角色:取任务(150)].副本id == 任务数据[id1.id].副本id then
				return true
			else
				return false
			end
		elseif 地图 >= 6027 and 地图 <= 6030 then
			if 玩家数据[id].角色:取任务(160) ~= 0 and 任务数据[玩家数据[id].角色:取任务(160)] ~= nil and 任务数据[玩家数据[id].角色:取任务(160)].副本id == 任务数据[id1.id].副本id then
				return true
			else
				return false
			end
		elseif 地图 >= 6031 and 地图 <= 6035 then
			if 玩家数据[id].角色:取任务(180) ~= 0 and 任务数据[玩家数据[id].角色:取任务(180)] ~= nil and 任务数据[玩家数据[id].角色:取任务(180)].副本id == 任务数据[id1.id].副本id then
				return true
			else
				return false
			end
		elseif 地图 >= 7001 and 地图 <= 7004 then
			if 玩家数据[id].角色:取任务(7001) ~= 0 and 任务数据[玩家数据[id].角色:取任务(7001)] ~= nil and 任务数据[玩家数据[id].角色:取任务(7001)].副本id == 任务数据[id1.id].副本id then
				return true
			else
				return false
			end
		elseif 地图 >= 6036 and 地图 <= 6039 then
			if 玩家数据[id] == nil then
				print("是id为NIL" .. id)
			elseif id1 == nil then
				print("是id1为NIL")
			elseif id1.id == nil then
				if type(id1.id) == "table" then
					table.print(id1)
				else
					print("是id1.id为nil")
				end
			elseif 任务数据[id1.id] == nil then
				print("是任务数据[id1.id]为NIL" .. id1.id)
			end

			if 玩家数据[id].角色:取任务(191) ~= 0 and 任务数据[玩家数据[id].角色:取任务(191)] ~= nil and 任务数据[玩家数据[id].角色:取任务(191)].副本id == 任务数据[id1.id].副本id then
				return true
			else
				return false
			end
		elseif 地图 == 34471 then
			if 玩家数据[id].角色:取任务(34471) ~= 0 and 任务数据[玩家数据[id].角色:取任务(34471)] ~= nil and 任务数据[玩家数据[id].角色:取任务(34471)].副本id == 任务数据[id1.id].副本id then
				return true
			else
				return false
			end
		else
			return false
		end
	elseif 地图 >= 1815 and 地图 <= 1875 then
		if 类型 == 1 then
			if 玩家数据[id].角色.数据.帮派数据 ~= nil and 玩家数据[id1].角色.数据.帮派数据 ~= nil and 玩家数据[id].角色.数据.帮派数据.编号 == 玩家数据[id1].角色.数据.帮派数据.编号 then
				return true
			else
				return false
			end
		elseif 玩家数据[id].角色.数据.帮派数据 ~= nil and 玩家数据[id1].角色.数据.帮派数据 ~= nil and 玩家数据[id].角色.数据.帮派数据.编号 == 玩家数据[id1].角色.数据.帮派数据.编号 then
			return true
		else
			return false
		end
	elseif 地图 >= 100000 and 地图 <= 400000000 then
		if #房屋数据 > 0 then
			for i = 1, #房屋数据 do
				for n = 1, #房屋数据[i].访问ID do
					if 房屋数据[i].ID == id and 玩家数据[id].角色.数据.房屋数据.编号 ~= 玩家数据[id1].角色.数据.房屋数据.编号 and 房屋数据[i].访问ID[n] ~= id1 then
						return false
					else
						return true
					end
				end
			end
		end
	elseif 地图 == 1210 or 地图 == 1092 or 地图 == 1179 or 地图 == 1187 or 地图 == 1178 or 地图 == 1210 or 地图 == 1208 or 地图 == 1210 or 地图 == 1042 or 地图 == 1206 then
		if 类型 == 1 then
			return true
		elseif 任务数据[id1.id].类型 >= 8800 and 任务数据[id1.id].类型 <= 8821 and 任务数据[id1.id].玩家id ~= id then
			return false
		else
			return true
		end
	else
		return true
	end
end

function 地图处理类:加入玩家(id, 地图编号, x, y)
	id = id + 0
	玩家数据[id].遇怪时间 = os.time() + 取随机数(10, 20)
	self.地图玩家[地图编号][id] = id

	发送数据(玩家数据[id].连接id, 1003, 取假人表(玩家数据[id].角色.数据.地图数据.编号))
	发送数据(玩家数据[id].连接id, 1004, 取传送点(玩家数据[id].角色.数据.地图数据.编号))
	摆摊假人处理类:摊位列表(玩家数据[id].连接id, 地图编号)

	if 自动遇怪[id] ~= nil then
		自动遇怪[id] = os.time()
	end

	if 自动捉鬼[id] ~= nil then
		自动捉鬼[id] = os.time()
	end

	for n, v in pairs(self.地图单位[地图编号]) do
		if self:取同一地图(地图编号, id, self.地图单位[地图编号][n], 2) then
			发送数据(玩家数据[id].连接id, 1015, self.地图单位[地图编号][n])
		end
	end

	玩家数据[id].移动数据 = {}

	for n, v in pairs(self.地图玩家[地图编号]) do
		if n ~= id and self:取同一地图(地图编号, id, n, 1) then
			发送数据(玩家数据[n].连接id, 1006, 玩家数据[id].角色:取地图数据())
			发送数据(玩家数据[id].连接id, 1006, 玩家数据[n].角色:取地图数据())

			if 玩家数据[n].移动数据 ~= nil and 玩家数据[n].移动数据.移动目标 ~= nil then
				发送数据(玩家数据[id].连接id, 1008, {
					数字id = n,
					路径 = 玩家数据[n].移动数据.移动目标
				})
			end
		end
	end

	if 假人系统 then
		BotManager:onPlayerJoin(地图编号, 玩家数据[id].连接id + 0)
	end
end

function 地图处理类:重连加入(id, 地图编号, x, y)
	id = id + 0
	local x待发送数据 = {}
	self.地图玩家[地图编号][id] = id

	发送数据(玩家数据[id].连接id, 1003, 取假人表(玩家数据[id].角色.数据.地图数据.编号))
	发送数据(玩家数据[id].连接id, 1004, 取传送点(玩家数据[id].角色.数据.地图数据.编号))
	摆摊假人处理类:摊位列表(玩家数据[id].连接id, 地图编号)

	for n, v in pairs(self.地图单位[地图编号]) do
		if self:取同一地图(地图编号, id, self.地图单位[地图编号][n], 2) then
			发送数据(玩家数据[id].连接id, 1015, self.地图单位[地图编号][n])
		end
	end

	for n, v in pairs(self.地图玩家[地图编号]) do
		if n ~= id and self:取同一地图(地图编号, id, n, 1) then
			发送数据(玩家数据[id].连接id, 1006, 玩家数据[n].角色:取地图数据())
		end
	end
end

function 地图处理类:加载房屋()
	if #房屋数据 > 0 then
		for n = 1, #房屋数据 do
			self.地图数据[房屋数据[n].庭院ID] = {
				npc = {},
				单位 = {},
				传送圈 = {}
			}
			self.地图玩家[房屋数据[n].庭院ID] = {}
			self.地图坐标[房屋数据[n].庭院ID] = 地图坐标类(房屋数据[n].庭院地图)
			self.地图单位[房屋数据[n].庭院ID] = {}
			self.单位编号[房屋数据[n].庭院ID] = 1000
			self.地图数据[房屋数据[n].房屋ID] = {
				npc = {},
				单位 = {},
				传送圈 = {}
			}
			self.地图玩家[房屋数据[n].房屋ID] = {}
			self.地图坐标[房屋数据[n].房屋ID] = 地图坐标类(房屋数据[n].房屋地图)
			self.地图单位[房屋数据[n].房屋ID] = {}
			self.单位编号[房屋数据[n].房屋ID] = 1000
		end
	end
end

function 地图处理类:显示(x, y)
end

return 地图处理类
